(function(window, undefined){
	var rat = (function(){
		var rat = function(selector, context){
			return new rat.fn.init(selector, context, rootRat);
		};

		rat.fn = rat.prototype = {
			constructor : rat,
			init : function(selector, context, rootRat){
				alert(selector);
			}
		};

		rat.fn.init.prototype = rat.fn;
		rat.extend = rat.fn.extend = function() {
            var options, name, src, copy, copyIsArray, clone,
            target = arguments[0] || {},
            i = 1,
            length = arguments.length,
            deep = false;
            // 如果第一个参数是boolean型，可能是深度拷贝
            if ( typeof target === "boolean" ) {
                deep = target;
                target = arguments[1] || {};
                // 跳过boolean和target，从第3个开始
                i = 2;
            }
            // target不是对象也不是函数，则强制设置为空对象
        if ( typeof target !== "object" && !rat.isFunction(target) ) {
            target = {};
        }
        // 如果只传入一个参数，则认为是对rat扩展
        if ( length === i ) {
           target = this;
           --i;
        }
        for ( ; i < length; i++ ) {
        // 只处理非空参数
            if ( (options = arguments[ i ]) != null ) {
                for ( name in options ) {
                src = target[ name ];
                copy = options[ name ];
                // 避免循环引用
                if ( target === copy ) {
                    continue;
                }
                // 深度拷贝且值是纯对象或数组，则递归
                if ( deep && copy && ( rat.isPlainObject(copy) || (copyIsArray = rat.isArray(copy)) ) ) {
                    // 如果copy是数组
                    if ( copyIsArray ) {
                        copyIsArray = false;
                        // clone为src的修正值
                        clone = src && tat.isArray(src) ? src : [];
                        // 如果copy的是对象
                    } else {
                     // clone为src的修正值
                     clone = src && rat.isPlainObject(src) ? src : {};
                    }
                    // 递归调用rat.extend
                    target[ name ] = rat.extend( deep, clone, copy );
                    // 不能拷贝空值
                } else if ( copy !== undefined ) {
                    target[ name ] = copy;
                }
            }
            }
        }
        // 返回更改后的对象
        return target;
    };
		return rat;
	})();
	window.rat = rat;
})(window);